Context aware synchronization using context and input parameter objects associated with a mutual exclusion lock

ABSTRACT

Examples are disclosed for context aware synchronization. A mutual exclusion (mutex) lock object or monitor may be created to enable threads to acquire a lock to access a shared data structure when executing a critical section of code. The mutex lock object may have at least a first input associated with a context via which the one or more threads execute the given critical block of code. The mutex lock object may then be stored in a shared memory and an indication as the where the mutex lock object was stored in the shared memory may be provided to a thread. The thread may use the mutex lock object to acquire the lock to access the shared data structure. Other mutex lock objects may be created in a similar manner to allow additional threads to acquire locks to access the shared data structure. Other examples are described and claimed.

BACKGROUND

Concurrent programs may include multiple threads or processes separately executing sections or blocks of code as part of the program that allows multiple tasks to be executed in parallel. This may result in race conditions in which different threads or processes make modifications to a common memory location represented by a shared data structure. The modifications to the shared data structure are done by executing software routines which access the shared data structure. These software routines may be referred to as a critical section or block of code. Modifications to the shared data structure may leave the shared data structure in an inconsistent state and may not produce the expected result during the execution of the program.

Synchronization may be a technique to prevent a race condition in which multiple threads or processes cooperate with each other for executing the critical section of code and only one thread or process executes the critical section at a time. Synchronization between threads may be achieved by a variety of techniques of which locking may be one of them. Mutually exclusive (mutex) is a type of lock in which a thread may be required to first acquire a lock on a mutex lock object before getting exclusive access to execute a critical section of code. The other threads may then need to acquire the lock on the mutex object before getting exclusive access to execute the critical section. For these examples, if the lock has already been acquired, a given thread may be configured to wait until the lock has been released on the mutex lock object before acquiring the lock. The given thread may then lock the mutex lock object to execute the given critical section of code while locking out other threads. In some examples, after executing the critical section, the given thread or process holding the lock may release it. Other threads waiting to acquire the lock on the mutex lock object may then try to acquire the lock to execute the critical section.

Acquiring a lock on a mutex lock object and then releasing the lock is an example methodology to ensure synchronization between threads that may modify the shared data structure during execution of the critical section of code. However, lock contention between different threads may slow down or stall a multi-threaded program. As the number of threads for a given multi-threaded program increases so does the likelihood of lock contention.

Additionally there can be multiple types of modification of the shared data structure which can be related or unrelated depending on a nature of the application, components of the application, use cases involved or the shared data structure in question. Mutual exclusion of threads by locking mechanism for any type of modification of a given shared data structure that is achieved by executing the same or multiple critical sections of code or routines may sometimes cause unnecessary delay in program execution. The unnecessary delay may result in performance degradation of the application. In particular, performance degradation may occur for modification operations that may not be related to each other, do not cause shared data structure inconsistency or induce an acceptable amount of shared data structure inconsistency.

Also, similar or different types of modifications to the shared data structure may occur within different execution conditions or environment settings. These modifications of the shared data structure under different environment setting or contexts may or may not be related to each other. In other words, concurrent modification of the shared data structure may or may not leave it in inconsistent situation under different contexts. Hence, concurrent modifications of the shared data structure may purely depend on a nature of an application or components of the application, use cases involved, the shared data structure in question as to what level of synchronization between different threads may be needed in different execution contexts.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an example first system.

FIG. 2 illustrates an example second system.

FIG. 3 illustrates an example flow diagram.

FIG. 4 illustrates an example apparatus.

FIG. 5 illustrates an example logic flow.

FIG. 6 illustrates an example storage medium.

FIG. 7 illustrates an example computing platform.

DETAILED DESCRIPTION

According to some examples, acquiring a lock and then releasing the lock via use of a mutex lock object may lead to lock contention between multiple threads separately executing a critical section or block of code that may modify a shared data structure. In object oriented paradigm, use of class level locks or instance level locks may further increase the likelihood of lock contention. The likelihood of lock contention may be increased because the lock contention may not distinguish between a shared data structure required for different critical portions of a given block of code inside a class or contexts under which execution of the critical section or block of code takes place.

Object-oriented programming such as Java™ typically associate monitors with an object. Java is a widely used programming language often associated with multi-threaded programs that may be implemented in networked and/or Internet-based computing systems that may require a high level of performance such as data centers or web hosting centers. As a result of Java's use in performance sensitive implementations, association of monitors with a shared object may lead to bottle necks and possibly unacceptable delays. The bottle necks may be due to lock contention caused by different threads waiting to separately acquire locks on a monitor for use of a shared data structure or structures possibly included in a broader shared object. It is with respect to these and other challenges that the examples described herein are needed.

In some examples, techniques associated with managing locks may be implemented. These techniques may include creating a mutex lock object for a thread to acquire a lock to access a shared data structure when executing a critical section or block of code. For these examples, the mutex lock object may have at least a first input associated with a context via which the thread executes the critical block of code. The mutex lock object may then be stored in in a shared memory and an indication may be provided to the thread to indicate where the mutex lock object has been stored in the shared memory. The thread may then acquire the lock on the shared data structure using the first mutex lock object. The thread may then execute the critical block of code while accessing the shared data structure while locking out other threads from accessing the shared data structure. Other mutex lock objects may be created in a similar manner to allow additional or other threads to acquire locks to access the shared data structure.

FIG. 1 illustrates an example first system. As shown in FIG. 1, the first system includes system 100. According to some examples, as shown in FIG. 1, system 100 includes a computing platform 105 coupled to network device(s) 130 via a communication link 135. In some examples, communication link 135 may function as a network communication link and computing platform 105 may serve as a type of cloud computing platform to manage one or more network device(s) 130. Network device(s) 130 may include, but are not limited to, storage servers, web hosting servers or data servers.

In some examples, as shown in FIG. 1, computing platform 105 includes circuitry 110 having multiple threads 112-1 to 112-n, where n equals any positive whole integer greater than 2, and a cache 114. According to some examples, cache 114 may serve as a shared memory or pool to at least temporary store information (e.g., mutex lock objects or monitors) used by threads 112-1 to 112-n to acquire locks to separately execute blocks of code as part of a multi-threaded program. Circuitry 110 may be capable of supporting threads 112-1 to 112-n for the separate execution of blocks of code and may include, for example, singly or in any combination, analog circuitry, digital circuitry, hardwired circuitry, programmable circuitry, co-processor circuitry, state machine circuitry, and/or memory that may include program instruction that may be executed by programmable circuitry. Also, in some examples, a processor circuit, host processor, processor core, multiple cores, or controller each may be included in circuitry 110 and may also be capable of supporting threads 112-1 to 112-n for the separate execution of blocks of code.

According to some examples, as shown in FIG. 1, computing platform 105 includes memory 120. Memory 120 may be arranged to include instances of an operating system (OS) 122 and middleware application(s) 124. In some examples, middleware application(s) 124 may facilitate communications or interactions between OS 122 and network management applications(s) 132 maintained at one or more network device(s) 130. For these examples, middleware application(s) 124 may utilize threads 112-1 to 112-n to execute a multi-threaded program to facilitate these communications or interactions. The multi-threaded program, for example, may enable an operator of computing platform 105 to manage and/or control network device(s) 130 using parallel processes implemented by threads 112-1 to 112-n separately executing a block of code as part of the multi-threaded program. As described in more detail below, techniques may be implemented to manage locks in order to minimize or reduce lock contention between threads such as threads 112-1 to 112-n when separately executing the block of code. As a result, performance for computing platform 105, in terms of managing or controlling network device(s) 130, may be improved.

FIG. 2 illustrates an example second system. As shown in FIG. 2, the second system includes system 200. According to some examples, system 200 includes a thread 210, a thread 220, an object routine 230, a shared memory/pool 240 and a shared data structure 250. According to some examples, as shown in FIG. 2, threads 210 and 220 may each have a respective code block 212 and 214. FIG. 2, according to some examples, also shows shared memory/pool 240 having mutex lock objects 242 and 244 having respective primary objects 242-A, 244-A, respective secondary objects 242-B, 244-B and respective lock indicators 242-C, 244-C.

In some examples, object routine 230 may be capable of creating mutex lock objects 242 or 244 and at least temporarily storing these mutex lock objects in shared memory/pool 240. Mutex lock objects 242 or 244 may enable thread 210 or thread 220 to acquire a lock to access shared data structure 250 to separately execute at least portions of their respective code blocks. For these examples, each of the mutex lock objects may have a primary object and a secondary object and a lock indicator. A primary object may be associated with an input parameter used by thread 210 or thread 220 to execute their respective code blocks. An input parameter may include, but is not limited to, an input data structure or a composite of input data structures to be used by either thread 210 or thread 220 to execute respective code blocks 212 and 222.

According to some examples, a secondary object may be associated with a given context via which thread 210 or thread 220 execute respective code blocks 212 and 222. The given context may be as simple as a string denoting a type of operation, which may include, but is not limited to, a delete operation, an add operation, a map operation, a create operation, an unmap operation or an update operation carried out or executed as a result of thread 210 or thread 220 executing respective code blocks 212 and 222. The given context may also be a more complex secondary object that encapsulates child objects representing different environments or execution conditions via which thread 210 or thread 220 may execute respective code blocks 212 and 222. For example, specific memory sizes associated with a type of operation, a number string assigned to a type of operation or attributes assigned to a type of operation. Other examples are possible and the above examples are not limited to the above examples of more complex secondary objects.

In some examples, complexity of the secondary object may be programmer defined based, at least in part, on needs of an application that at least portions of which may be executed by threads 210 or thread 220. Also, scenario requirements may assist the programmer in defining a complexity of the secondary object. For example, a less complex or coarsely defined secondary object may be used in secure application scenarios that may narrow the chances or probability of threads 210 and 220 simultaneously obtaining locks for shared data structures for a given critical section of code of a more secure application. However, the coarsely defined secondary object may lessen performance of a multi-threaded execution. A more complex or fine-grained secondary object may be used for less security-sensitive applications that, although less security-sensitive, may have higher performance for parallel execution.

In some examples, as described in more detail below, object routine 230 may be capable of managing locks for shared data structure 250 by creating mutex lock objects that are based on primary and secondary objects such as those included in mutex lock objects 242 or 244. As described more below, a routine may be completed by object routine 230 to possibly create and/or provide an indication to thread 210 or thread 220 as to where mutex lock objects are stored in shared memory/pool 240 (e.g., via a memory pointer or a hash). Based on this indication, thread 210 or thread 220 may have access to respective lock indicators 242-C or 244-C.

According to some examples, threads 210 or 220 may then use this access to either acquire or wait for acquisition of a lock on mutex object 242 or 244 for accessing shared data structure 250. For example, threads 210 and 220 may separately place mutex lock object requests to object routine 230 to acquire a lock for accessing shared data structure 250. Responsive to these requests, object routine 230 may provide an indicator of where a mutex lock object matching the mutex lock object requests is/are located. A matching mutex lock object request may be based on a primary object (e.g., input parameter) and a secondary object (e.g., context) separately indicated in the separate mutex lock object requests. If both mutex lock object requests include the same primary and secondary objects, then both threads 210 and 220 may be provided with the same location indication (same lock indicator) and thus may have a lock contention as each thread attempts to acquire the same lock. However, if either primary or secondary objects are different, then threads 210 and 220 may be provided with different location indications (different lock indicators) and thus may have no lock contention as each thread may have their own and different lock for access to shared data structure 250.

According to some examples, mutex lock objects 242 or 244 may be also be referred to as monitors (e.g., in Java implementations). For these examples, object routine 230 may have first created monitors or mutex lock objects 242 or 244 responsive to a mutex lock object request received from threads 210 or 220. Following creation of monitors or mutex lock objects 242 or 244, these mutex lock object/monitors may be at least temporarily stored in shared memory/pool 240. In some examples, a size or longevity of shared memory/pool 240 may be programmer controlled or configurable based on application needs or scenario requirements (e.g., secure vs. less secure).

FIG. 3 illustrates example flow diagram 300. In some examples, flow diagram 300 may be for managing locks to access a shared data structure. For these examples, elements of system 200 as shown in FIG. 2 may be used to illustrate example operations related to flow diagram 300. However, the example processes or operations are not limited to implementations using elements of system 200. According to some examples, as shown in FIG. 3, thread 210 may implement a series of operations that may be mirrored by thread 220. Also, in some examples, these mirrored operations may interact with operations implemented by object routine 230. The operations implemented by object routine 230 are depicted in FIG. 3 as those operations within the dashed-line box.

According to some examples, thread 210 and thread 220 may be somewhat simultaneously executing respective code blocks 212 and 222. For ease of description, operations implemented by thread 210 and responsive interactions with object routine 230 are described first. Operations implemented by thread 220 and responsive interactions with object routine 230 are then described. Examples are not limited to this order of implementation; the order may be switched or may occur concurrently.

Moving from start 302 to block 304 (Mutex Lock Object Request), thread 210 executing code block 212 may cause a first mutex lock object request to be sent to object routine 230. In some examples, the first mutex lock object request may include both a first primary object and a first secondary object. For these examples, the first primary object may be associated with a first input parameter used by thread 210 to executed code block 212. The first secondary object may be associated with a first context via which thread 210 executes code block 212. For example, the first context may be a delete operation and/or attributes assigned to the delete operation.

Proceeding from block 304 to start 322, the first mutex lock object request from thread may be received by object routine 230.

Proceeding from start 322 to block 324 (Process Mutex Lock Object Request), object routine 230 may begin implementation of a first routine responsive to the first mutex lock object request from thread 210 in order to process the first mutex lock object request.

Proceeding from block 324 to decision block 326 (Exist in Pool?), object routine 230 may determine whether a first mutex lock object matching the first primary and secondary objects included in the first mutex lock object request from thread 210 is maintained in shared memory/pool 240. For example, object routine 230 may be capable of determining whether the primary and secondary objects match the primary and secondary object included in any one of mutex lock objects 242 or 244. If the primary and secondary objects do not match, the process moves to block 328. Otherwise, the process moves to block 330.

Moving from decision block 326 to block 328 (Add Mutex Lock Object), object routine 230 may create a first mutex lock object based on the first primary and secondary objects included in the first mutex lock object request from thread 210 that also includes a lock indicator. For example, the newly created mutex lock object may then be stored in shared memory/pool 240.

Moving from decision block 326 to block 330 (Provide Pointer/Hash), object routine 230 may have determined that the first primary and secondary objects included in the first mutex lock object request do match a first mutex lock object currently maintained in shared memory/pool 240 or object routine 230 may have stored a newly created first mutex lock object in shared memory/pool 240. In either example, object routine 230 may provide a first indication as where the first mutex lock object associated with the first mutex lock object request has been stored in shared memory/pool 240. The indication, for example, may include, but is not limited to, providing a pointer to a location (e.g., a logic or physical memory address) in shared memory/pool 240 where the first mutex lock object has been stored or a hash for thread 210 to determine where the first mutex lock object has been stored (e.g., via use of a hash function).

Proceeding from block 330 to end 332 the routine implemented by object routine 230 responsive to the first mutex lock object request from thread 210 to provide a mutex lock object comes to an end.

Moving from the end 332 to block 306 (Acquire Lock), thread 210 may use the first indication of the location of the first mutex lock object to determine whether another thread has acquired a first lock to access shared data structure 250. In some examples, the first mutex lock object may be mutex lock object 242 and lock indicator 242-C may indicate whether another thread currently has acquired the first lock. For example, lock indicator 242-C may be an indicator bit capable of being selectively asserted to have a “1” value to indicate a lock has been acquired by another thread or a “0” value to indicate a lock has not been acquired or has been released. Thread 210 may use the first indicator received from object routine 230 to locate mutex lock object 242 and check lock indicator 242-C to see if it indicates whether the first lock is acquirable by thread 210 (e.g., not acquired by another thread).

Proceeding from block 306 to decision block 310 (Acquired?), thread 210 may determine whether indicator 242-C indicates the first lock is acquirable. If the first lock is acquirable, the first lock is acquired and the process moves to block 310. Otherwise, the process moves to block 306. In some examples, to acquire the first lock, thread 210 may be capable of asserting the indicator bit of lock indicator 242-C to indicate that the first lock has been acquired.

Moving from decision block 308 to block 310 (Execute Code Block), thread 210 may then execute code block 212 and have access to shared data structure 250 while locking out other threads that need to acquire the same lock to also access shared data structure 250.

Moving from block 310 to block 312 (Release Lock), thread 210 may release the first lock on shared data structure 250. In some examples, thread 210 may be capable of de-asserting the indicator bit of lock indicator 242-C to indicate that the first lock has been released. Thread 210 may then move to end 314

In some examples, proceeding from block 312 to start 342, the indication of release of the first lock may initiate a second routine by object routine 230. The second routine may determine whether mutex lock object 242 needs to remain in shared memory/pool 240.

For this second routine, the process moves from start 342 to decision block 344 (Lock Acquired?). In some examples, object routine 230 may determine whether another thread has acquired the first lock following thread 210's release. If another thread has acquired the first lock, then mutex lock object 242 remains in shared memory/pool 240 and the process moves to end 348 and the second routine initiated by thread 210's release may end. Otherwise, the process moves to block 346.

Moving from decision block 344 to block 346 (Remove Object), object routine 230 may remove mutex lock object 242. In some examples, mutex lock object 242 may be removed to keep the contents of shared memory/pool 240 from becoming too large and thus making addressing schemes more complex and possibly adding to access latencies for threads to quickly check lock indicators to acquire or wait for acquiring a given lock. The process then moves to end 348 and the second routine initiated by thread 210's release may end.

Moving from start 352 to block 354 (Mutex Lock Object Request), thread 220 executing code block 222 may cause a second mutex lock object request to be sent to object routine 230. In some examples, the second mutex lock object request may include both a second primary object and a second secondary object. For these examples, the second primary object may be associated with a second input parameter used by thread 220 to executed code block 222. The second secondary object may be associated with a second context via which thread 220 executes code block 222. For example, the second context may be an update operation and/or an assigned memory size for the update operation.

Proceeding from block 354 to start 322, the second mutex lock object request from thread 220 may be received by object routine 230.

Proceeding from start 322 to block 324 (Process Mutex Lock Object Request), object routine 230 may begin implementation of the first routine mentioned above for the first mutex lock object request. The first routine may be implemented responsive to the second mutex lock object request from thread 220 in order to process the second mutex lock object request.

Proceeding from block 324 to decision block 326 (Exist in Pool?), object routine 230 may determine whether a mutex lock object matching the second primary and secondary objects included in the second mutex lock object request from thread 220 is maintained in shared memory/pool 240. For example, object routine 230 may be capable of determining whether the second primary and secondary objects match the primary and secondary object included in any one of mutex lock objects 242 or 244. If the primary and secondary objects do not match, the process moves to block 328. Otherwise, the process moves to block 330.

Moving from decision block 326 to block 328 (Add Mutex Lock Object), object routine 230 may create a second mutex lock object based on the second primary and secondary objects included in the second mutex lock object request from thread 220 that also includes a lock indicator. For example, the newly created mutex lock object may then be stored in shared memory/pool 240.

Moving from decision block 326 to block 330 (Provide Pointer/Hash), object routine 230 may have determined that the second primary and secondary objects included in the first mutex lock object request do match a mutex lock object currently maintained in shared memory/pool 240 or object routine 230 may have stored a newly created a second mutex lock object in shared memory/pool 240. In either example, object routine 230 may provide a second indication as where the second mutex lock object associated with the second mutex lock object request has been stored in shared memory/pool 240. The indication, for example, may include, but is not limited to, providing a pointer to a location in shared memory/pool 240 where the second mutex lock object has been stored or a hash for thread 220 to determine where the second mutex lock object has been stored.

Proceeding from block 330 to end 332 the routine implemented by object routine 230 responsive to the second mutex lock object request from thread 220 to provide a mutex lock object comes to an end.

Moving from the end 332 to block 356 (Acquire Lock), thread 220 may use the second indication of the location of the second mutex lock object to determine whether another thread has acquired a second lock to access shared data structure 250. In some examples, the second mutex lock object may be mutex lock object 244 and lock indicator 244-C may indicate whether another thread currently has acquired the second lock. Thread 220 may use the second indicator received from object routine 230 to locate mutex lock object 244 and check lock indicator 242-C to see it if indicates whether the second lock is acquirable by thread 220 (e.g., not acquired by another thread).

Proceeding from block 356 to decision block 358 (Acquired?), thread 220 may determine whether indicator 244-C indicates the second lock is acquirable. If the second lock is acquirable, the second lock is acquired and the process moves to block 360. Otherwise, the process moves to block 356. In some examples, to acquire the second lock, thread 220 may be capable of asserting an indicator bit of lock indicator 244-C to indicate that the second lock has been acquired.

Moving from decision block 358 to block 360 (Execute Code Block), thread 220 may then execute code block 222 and have access to shared data structure 250 while locking out other threads that need to acquire the same lock to also access shared data structure 250.

Moving from block 360 to block 362 (Release Lock), thread 220 may release the second lock on shared data structure 250. In some examples, thread 220 may be capable of de-asserting the indicator bit of lock indicator 244-C to indicate that the second lock has been released. Thread 220 may then move to end 364

In some examples, proceeding from block 362 to start 342, the indication of release of the second lock may initiate the second routine by object routine 230. The second routine may determine whether mutex lock object 244 needs to remain in shared memory/pool 240.

For this second routine, the process moves from start 342 to decision block 344 (Lock Acquired?). In some examples, object routine 230 may determine whether another thread has acquired the second lock following thread 220's release. If another thread has acquired the second lock, then mutex lock object 244 remains in shared memory/pool 240 and the process moves to end 348 and the second routine initiated by thread 220's release may end. Otherwise, the process moves to block 346.

Moving from decision block 344 to block 346 (Remove Mutex Lock Object), object routine 230 may remove mutex lock object 244. The process then moves to end 348 and the second routine initiated by thread 220's release may end.

According to some examples, each time threads 210 or 220 need to once again acquire a lock to access shared data structure 250, the process may start again at either start 302 or start 352.

FIG. 4 illustrates an example apparatus 400. Although the apparatus 400 shown in FIG. 4 has a limited number of elements in a certain topology, it may be appreciated that the apparatus 400 may include more or less elements in alternate topologies as desired for a given implementation.

The apparatus 400 may comprise a computer-implemented apparatus that may encompass at least some of the capabilities mentioned above for object routine 230 for FIGS. 2-3. The computer-implemented apparatus 400 may be arranged to execute one or more software modules 422-a. It is worthy to note that “a” and “b” and “c” and similar designators as used herein are intended to be variables representing any positive integer. Thus, for example, if an implementation sets a value for a=5, then a complete set of software modules 422-a may include modules 422-1, 422-2, 422-3, 422-4 or 422-5. The examples are not limited in this context.

In some examples, as shown in FIG. 4, apparatus 400 includes circuitry 420. Circuitry 420 may be generally arranged to execute one or more modules 422-a as well as executing a multi-threaded program. Circuitry 420 can be any of various commercially available processors, including without limitation an AMD®, Athlon®, Duron® and Opteron® processors; ARM® application, embedded and secure processors; IBM® and Motorola® DragonBall® and PowerPC® processors; IBM and Sony® Cell processors; Qualcomm® Snapdragon®; Intel® Celeron®, Core (2) Duo®, Core i3, Core i5, Core i7, Itanium®, Pentium®, Xeon®, Atom® and XScale® processors; and similar processors. Dual microprocessors, multi-core processors, and other multi-processor architectures may also be employed as circuitry 420. According to some examples circuitry 420 may also include an application specific integrated circuit (ASIC) and modules 422-a may be implemented as hardware elements of the ASIC.

According to some examples, apparatus 400 may include a receive module 422-1. Receive module 422-1 may be executed by circuitry 420 to receive mutex lock object request(s) 410 from threads separately executing blocks of code as part of a multi-threaded program. Each received mutex lock object request may include a primary and secondary object as mentioned above for FIGS. 2-3. Receive module 422-1 may be capable of at least temporarily maintaining primary and secondary objects with primary object information 424-a and secondary object information 426-b. Primary object information 424-a and secondary object information 426-b may be maintained in a data structure such as a lookup table (LUT).

In some examples, apparatus 400 may also include a create module 422-2. Create module 422-2 may be executed by circuitry 420 to create one or more mutex lock objects for threads to acquire one or more locks to access a shared data structure when separately executing blocks of code as part of the multi-threaded program. For these examples, create module 422-2 may use the primary and secondary objects received by receive module 422-1 and add a lock indicator for possible use by the threads to acquire a given lock to access the shared data structure. Create module 422-2 may be capable of at least temporarily maintaining created mutex lock objects with mutex lock object(s) 428-c (e.g., in a LUT).

In some examples, apparatus 400 may also include a storage module 422-3. Storage module 422-3 may be executed by circuitry 420 to store the one or more mutex lock objects created by create module 422-2 in a shared memory. For these examples, storage module 422-3 may maintain shared memory/pool information 430-d (e.g., in a LUT) to track where mutex lock objects have been stored to the shared memory. The stored mutex lock objects may be included in mutex lock object(s) to storage 440.

According to some examples, apparatus 400 may also include an indicate module 422-4. Indicate module 422-4 may be executed by circuitry 420 to provide indications to the threads as to where mutex lock objects have been stored to the shared memory. For these examples, indicate module 422-4 may be capable of maintaining location information (e.g., pointers and/or hashes) with mutex lock object(s) information 432-a (e.g., in a LUT). Following receipt of a mutex lock object request by receive module 422-1, indicate module 422-4 may provide indications to the requesting thread via mutex lock object location(s) 450.

In some examples, apparatus 400 may also include a clean module 422-5. Clean module 422-5 may be executed by circuitry 420 to receive an indication that a given thread has released an acquired lock for accessing the shared data structure. For these examples, clean module 422-5 may then cause a mutex lock object used to acquire the now released lock to be removed from the shared memory. Clean module 422-5 may cause the mutex lock object removal from the shared memory based on whether another thread has acquired the lock after the lock was released.

Included herein is a set of logic flows representative of example methodologies for performing novel aspects of the disclosed architecture. While, for purposes of simplicity of explanation, the one or more methodologies shown herein are shown and described as a series of acts, those skilled in the art will understand and appreciate that the methodologies are not limited by the order of acts. Some acts may, in accordance therewith, occur in a different order and/or concurrently with other acts from that shown and described herein. For example, those skilled in the art will understand and appreciate that a methodology could alternatively be represented as a series of interrelated states or events, such as in a state diagram. Moreover, not all acts illustrated in a methodology may be required for a novel implementation.

A logic flow may be implemented in software, firmware, and/or hardware. In software and firmware embodiments, a logic flow may be implemented by computer executable instructions stored on at least one non-transitory computer readable medium or machine readable medium, such as an optical, magnetic or semiconductor storage. The embodiments are not limited in this context.

FIG. 5 illustrates a logic flow 500. Logic flow 500 may be representative of some or all of the operations executed by one or more logic, features, or devices described herein, such as apparatus 400. More particularly, logic flow 500 may be implemented by receive module 422-1, create module 422-2, storage module 422-3, indicate module 422-4 or clean module 422-5.

In some examples, logic flow 500 at block 502 may create a mutex lock object for a thread to acquire a lock to access a shared data structure when executing a critical section or block of code. The mutex lock object may have a primary object associated with an input parameter used by the thread to execute the block of code. The mutex lock object may also have a secondary object associated with a context via which the thread executes the block of code. For these examples, create module 422-2 may create the mutex lock object based on a mutex lock object request received by receive module 422-1.

According to some examples, logic flow 500 at block 504 may store the mutex lock object in a shared memory. For these examples, storage module 422-3 may store the mutex lock object created by create module 422-2 in a shared memory/pool.

According to some examples, logic flow 500 at block 506 may provide to the thread an indication as to a location in the shared memory where the mutex lock object has been stored. The thread may then acquire the lock to access the shared data structure using the mutex lock object. For these examples, indicate module 422-4 may provide the indication to the thread.

In some examples, logic flow 500 at block 508 may determine that the thread has released the acquired lock and may then remove the mutex lock object from the shared memory based on a determination of whether another thread has acquired the lock. For these examples, clean module 422-5 may make the determination and remove the mutex lock object based on that determination.

FIG. 6 illustrates an embodiment of a storage medium 600. The storage medium 600 may comprise an article of manufacture. In some examples, storage medium 600 may include any non-transitory computer readable medium or machine readable medium, such as an optical, magnetic or semiconductor storage. Storage medium 600 may store various types of computer executable instructions, such as instructions to implement logic flow 500. Examples of a computer readable or machine readable storage medium may include any tangible media capable of storing electronic data, including volatile memory or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writeable or re-writeable memory, and so forth. Examples of computer executable instructions may include any suitable type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, object-oriented code, visual code, and the like. The examples are not limited in this context.

FIG. 7 illustrates an example computing device 700. In some examples, as shown in FIG. 7, computing device 700 may include a processing component 740, other platform components 750 or a communications interface 760.

According to some examples, processing component 740 may execute processing operations or logic for apparatus 400 and/or computer readable medium 600. Processing component 740 may include various hardware elements, software elements, or a combination of both. Examples of hardware elements may include devices, logic devices, components, processors, microprocessors, circuits, processor circuits, circuit elements (e.g., transistors, resistors, capacitors, inductors, and so forth), integrated circuits, application specific integrated circuits (ASIC), programmable logic devices (PLD), digital signal processors (DSP), field programmable gate array (FPGA), memory units, logic gates, registers, semiconductor device, chips, microchips, chip sets, and so forth. Examples of software elements may include software components, programs, applications, computer programs, application programs, system programs, software development programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application program interfaces (API), instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. Determining whether an example is implemented using hardware elements and/or software elements may vary in accordance with any number of factors, such as desired computational rate, power levels, heat tolerances, processing cycle budget, input data rates, output data rates, memory resources, data bus speeds and other design or performance constraints, as desired for a given example.

In some examples, other platform components 750 may include common computing elements, such as one or more processors, multi-core processors, co-processors, memory units, chipsets, controllers, peripherals, interfaces, oscillators, timing devices, video cards, audio cards, multimedia input/output (I/O) components (e.g., digital displays), power supplies, and so forth. Examples of memory units associated with either other platform components 750 may include without limitation, various types of computer readable and machine readable storage media in the form of one or more higher speed memory units, such as ROM, RAM, DRAM, Double-Data-Rate DRAM (DDRAM), synchronous DRAM (SDRAM), SRAM, programmable ROM (PROM), EPROM, EEPROM, NAND flash memory, NOR flash memory, polymer memory such as ferroelectric polymer memory, ferroelectric transistor random access memory (FeTRAM or FeRAM), nanowire, ovonic memory, ferroelectric memory, 3-dimentional cross-point memory, SONOS memory, magnetic or optical cards, an array of devices such as Redundant Array of Independent Disks (RAID) drives, solid state memory devices (e.g., USB memory), SSDs and any other type of storage media suitable for storing information.

In some examples, communications interface 760 may include logic and/or features to support a communication interface. For these examples, communications interface 760 may include one or more communication interfaces that operate according to various communication protocols or standards to communicate over direct or network communication links. Direct communications may occur via use of communication protocols or standards described in one or more industry standards (including progenies and variants) to include the Peripheral Component Interconnect (PCI) Express Base Specification, revision 3.0, published in November 2010 (“PCI Express” or “PCIe”), the Universal Serial Bus Specification, revision 3.0, published in November 2008 (“USB”), the Serial ATA (SATA) Specification, revision 3.1, published in July 2001, Request for Comments (RFC) 3720, Internet Small Computer System Interface (iSCSI), published in April 2004 and/or the Serial Attached SCSI (SAS) Specification, revision 2.1, published in December 2010. Network communications may occur via use of various communication protocols and may operate in compliance with one or more promulgated standards or specifications for wired or wireless networks by the Institute of Electrical Engineers (IEEE). These standards are specifications may include, but are not limited to, IEEE 802.11-2012 Standard for Information technology—Telecommunications and information exchange between systems—Local and metropolitan area networks—Specific requirements Part 11: WLAN Media Access Controller (MAC) and Physical Layer (PHY) Specifications, published March 2012, later versions of this standard (“IEEE 802.11”) for wireless mediums or IEEE 802.3-2008, Carrier sense Multiple access with Collision Detection (CSMA/CD) Access Method and Physical Layer Specifications, Published in December 2008 (hereinafter “IEEE 802.3”) for wired mediums, one or more protocols that may encapsulate Fibre Channel frames over Ethernet networks referred to as fiber channel over Ethernet (FCoE), compatible with the protocols described by the American National Standard of Accredited Standards Committee INCITS T11 Technical Committee, Fibre Channel Backbone-5 (FC-BB-5) Standard, Revision 2.0, published June 2009 and/or protocols associated with RFC 3530, Network File System (NFS), version 4 Protocol, published in April 2003.

Computing device 700 may be part of a system or device that may be, for example, user equipment, a computer, a personal computer (PC), a desktop computer, a laptop computer, a notebook computer, a netbook computer, a tablet computer, a tablet, a portable gaming console, a portable media player, a smart phone, a server, a server array or server farm, a web server, a network server, an Internet server, a work station, a mini-computer, a main frame computer, a supercomputer, a network appliance, a web appliance, a distributed computing system, multiprocessor systems, processor-based systems, or combination thereof. Accordingly, functions and/or specific configurations of computing device 700 described herein, may be included or omitted in various embodiments of computing device 700, as suitably desired.

The components and features of computing device 700 may be implemented using any combination of discrete circuitry, application specific integrated circuits (ASICs), logic gates and/or single chip architectures. Further, the features of computing device 700 may be implemented using microcontrollers, programmable logic arrays and/or microprocessors or any combination of the foregoing where suitably appropriate. It is noted that hardware, firmware and/or software elements may be collectively or individually referred to herein as “logic” or “circuit.”

It should be appreciated that the exemplary computing device 700 shown in the block diagram of FIG. 7 may represent one functionally descriptive example of many potential implementations. Accordingly, division, omission or inclusion of block functions depicted in the accompanying figures does not infer that the hardware components, circuits, software and/or elements for implementing these functions would necessarily be divided, omitted, or included in embodiments.

One or more aspects of at least one example may be implemented by representative instructions stored on at least one machine-readable medium which represents various logic within the processor, which when read by a machine, computing device or system causes the machine, computing device or system to fabricate logic to perform the techniques described herein. Such representations, known as “IP cores” may be stored on a tangible, machine readable medium and supplied to various customers or manufacturing facilities to load into the fabrication machines that actually make the logic or processor.

Various examples may be implemented using hardware elements, software elements, or a combination of both. In some examples, hardware elements may include devices, components, processors, microprocessors, circuits, circuit elements (e.g., transistors, resistors, capacitors, inductors, and so forth), integrated circuits, application specific integrated circuits (ASIC), programmable logic devices (PLD), digital signal processors (DSP), field programmable gate array (FPGA), memory units, logic gates, registers, semiconductor device, chips, microchips, chip sets, and so forth. In some examples, software elements may include software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application program interfaces (API), instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. Determining whether an example is implemented using hardware elements and/or software elements may vary in accordance with any number of factors, such as desired computational rate, power levels, heat tolerances, processing cycle budget, input data rates, output data rates, memory resources, data bus speeds and other design or performance constraints, as desired for a given implementation.

Some examples may include an article of manufacture or at least one computer-readable medium. A computer-readable medium may include a non-transitory storage medium to store logic. In some examples, the non-transitory storage medium may include one or more types of computer-readable storage media capable of storing electronic data, including volatile memory or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writeable or re-writeable memory, and so forth. In some examples, the logic may include various software elements, such as software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, API, instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof.

According to some examples, a computer-readable medium may include a non-transitory storage medium to store or maintain instructions that when executed by a machine, computing device or system, cause the machine, computing device or system to perform methods and/or operations in accordance with the described examples. The instructions may include any suitable type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, and the like. The instructions may be implemented according to a predefined computer language, manner or syntax, for instructing a machine, computing device or system to perform a certain function. The instructions may be implemented using any suitable high-level, low-level, object-oriented, visual, compiled and/or interpreted programming language.

Some examples may be described using the expression “in one example” or “an example” along with their derivatives. These terms mean that a particular feature, structure, or characteristic described in connection with the example is included in at least one example. The appearances of the phrase “in one example” in various places in the specification are not necessarily all referring to the same example.

Some examples may be described using the expression “coupled” and “connected” along with their derivatives. These terms are not necessarily intended as synonyms for each other. For example, descriptions using the terms “connected” and/or “coupled” may indicate that two or more elements are in direct physical or electrical contact with each other. The term “coupled,” however, may also mean that two or more elements are not in direct contact with each other, but yet still co-operate or interact with each other.

It is emphasized that the Abstract of the Disclosure is provided to comply with 37 C.F.R. Section 1.72(b), requiring an abstract that will allow the reader to quickly ascertain the nature of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, in the foregoing Detailed Description, it can be seen that various features are grouped together in a single example for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed examples require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in less than all features of a single disclosed example. Thus the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as a separate example. In the appended claims, the terms “including” and “in which” are used as the plain-English equivalents of the respective terms “comprising” and “wherein,” respectively. Moreover, the terms “first,” “second,” “third,” and so forth, are used merely as labels, and are not intended to impose numerical requirements on their objects.

In some examples, a first method to create mutex lock object using execution context object may include creating a mutex lock object to be used by threads or processes for locking before entering the critical section which accesses and modifies the shared data structure or shared object in memory. For this first method, a mutex creation routine may accept context as one of the inputs with or without any other defined inputs and create mutex lock object using it or bind context to the mutex lock object in a well-defined manner. Context, in some examples, may be an object which will hold the environment settings under which the thread or process execution may be taking place and the critical section behavior as defined by the programmer. Context object, to be passed to mutex creation routine which will be used for locking before executing any defined critical section, may be programmer defined and can be as simple as a string representing the type of operation like create, map, unmap, delete or just modify etc. or a more complex object encapsulating many environment settings as attributes and critical section behavior.

According to some examples, a second method may manage a mutex lock object life cycle. The second method may include placing a created mutex lock object into a defined object pool at a known memory location for a time any thread or process holds lock on it or are in queue to acquire a lock on it or till the configured interval after the last time lock was released on the mutex lock object. Any new thread or process requesting a mutex lock object will need to supply all the inputs for lock creation with context object as one of the inputs to a mutex creation routine that created the mutex lock object. The life cycle management routine will be called by mutex creation routine to check if any known mutex lock object matching the inputs is present in the object pool. If a mutex lock object is located, then the reference to it is passed to the mutex creation routine which may then pass it to the thread or process requesting the mutex lock object. The thread or process may need to query the mutex lock object and determine if a lock on the mutex lock object is held by any other thread or process and may be configured to wait till the lock becomes available. A new mutex lock object may be created if no matching mutex object is found in the object pool. The reference to newly created mutex object may be returned to the create mutex object routine which returns it back to the requesting thread of process. A life cycle management routine may also scan the mutex lock object pool in configured intervals or at a defined moment to verify if the mutex lock object is not locked by any thread or process and the expiry conditions for the mutex lock object have been met. The mutex lock object may then be removed from the pool to free memory if the said conditions have been met.

In some examples, a third method to manage lock contention between threads or processes for a mutex lock object may include a programmer defined context object that includes chosen attributes for a thread or process execution environment and attributes representing behavior of critical section which is then used by a mutex creation routine to create a mutex lock object. For this third method, any thread or process in execution will have the information about its state and its environment conditions. The programmer may understand a nature of the application, a nature of the application component having the critical section, a shared data structure which is to be modified by the critical section or type and extent of modification of the data structure possible within the critical section. Based on the information known about the critical section and the use case the critical section will be addressing in the application, the programmer may configure or write logic to extract all or selective environment settings for the thread or process in execution. The programmer may also add some more attributes representing the behavior of critical section, which will be entered into by the thread or process, into a context object and supply this context object as one of the inputs to the mutex lock object creation routine. A mutex lock object will be created and placed into the object pool. The same mutex object will be locked by the thread or process before entering the critical section. If another thread approaches another critical section which makes modifications to the same shared data structure and the thread or process has same environment settings but the critical section behavior i.e. type of modification to shared data structure is different than the critical section in the first thread then it will result in a different overall context object defined by the programmer. This second context object when supplied as one of the inputs to mutex creation routine will return a different mutex lock object than the one returned to the first thread. The second thread can acquire the lock on the second mutex lock object without waiting for the first thread to release the lock on the first mutex lock object. Even though both the routines are modifying the same shared data structure but as explained above, the overall context object comes different and hence the mutex lock object returned is also different. The context object may be completely programmer defined based on the known execution environment conditions, critical section behavior or the amount of execution isolation or protection needed for the shared data structure. The selection of execution environment and critical section behavior attributes to be used for creating context object may also be completely controlled by logic defined by the programmer and may or may not be used for defining context object used in mutex lock creation routine. This may help in managing the lock contentions for different critical sections in the application.

In some examples, a fourth method to manage thread or process execution throttling may include multiple threads or processes that want to execute a given critical section needed to acquire a lock on a mutex lock object before entering the critical section. Ordinarily, mutex lock object not encapsulating context object will be same for all threads or processes approaching the critical section or critical sections which modify a given shared data structure. For these examples, if any thread or process has acquired a lock on this given mutex lock object, other threads or processes have to wait till the lock on the mutex lock object has been released by the thread or process acquiring it before they can acquire a lock on the mutex lock object and enter into any critical section which makes modifications to the shared data structure. This bottleneck can be adjusted by taking into consideration the context object that may include thread or process execution environment settings and critical section behavior while creating or initializing a mutex lock object. Thus, even if the different critical sections modify the same shared data structure, based on thread or process environment settings and critical section behavior, context object is same or different, the returned mutex lock object can be same or different. This will enable control of the concurrent execution of a critical section or multiple critical sections by threads or processes based on application needs, critical section behavior, shared data structure in question or use cases involved. Thus the thread or process execution throttling can be configured or adjusted based on application demands by controlling the context object.

According to some examples, a fifth method to balance application performance and shared data protection may include applications or application components that have critical sections. These critical sections may prevent shared data structures in the application from concurrent modifications. In some scenarios, the possibility of any given shared data structure getting corrupt due to concurrent modifications may not be as critical as the desired application component performance. Hence, multiple threads or processes may need different mutex lock objects to lock before executing the critical section modifying the shared data structure which can be achieved by defining context objects which will be different from one another and will be same only when it's absolutely required. Thus even when a minimal concurrent execution protection is required for the critical section it may not matter much if the shared data structure becomes less reliable after modifications. This may give enhanced application performance but lesser concurrency protection for critical section or shared data structure modified in the critical section. In other scenarios shared data structure protection may be of utmost importance and lesser application performance is acceptable. In these other scenarios, a more coarse context object can be defined by a programmer for creating a mutex lock object in which chances of getting the same mutex lock object are higher. The returned mutex lock object may be used by threads or processes to lock before executing a critical section or multiple critical sections making modifications to a shared data structure. This may give enhanced protection to the shared data structure and compromise performance. Thus, context object can be used as a tool by the programmer for balancing between application performance and shared data protection in a desired manner based on application needs.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims. 

What is claimed is:
 1. A method for a mutual exclusion (mutex) lock object created for use by threads or processes for locking before entering a critical section or block of code which accesses and modifies a shared data structure or shared object in a memory, the method comprising: accepting context as a first input for one or more mutex lock objects, the context accepted with or without other defined inputs; binding the context to the one or more mutex lock objects in a well-defined manner, the context to include a context object that holds environment settings under which a thread or process execution takes place and a defined critical section behavior, the context object to also be programmer defined to include at least one of a simple context object having a string representing a type of operation being executed by the thread or process to include a create, a map, an unmap, a delete or a modify operation or a complex context object encapsulating a multitude of environment settings as attributes and critical section behavior; and passing the context object to a mutex creation routine arranged to use the context object to create a first mutex lock object for locking before the thread or process executes any defined critical section.
 2. The method of claim 1, comprising: placing the first mutex lock object in a defined object pool at a first known memory location for one of a first time period for which the thread or process or other threads or processes holds lock on the first mutex lock object or a predetermined first time interval from a last time a lock was released on the first mutex lock object; receiving a given input from the thread or process and compare the given input to the first input for the first mutex lock object to determine if the given input matches the first input; providing the first mutex lock object to the thread or process if a match is determined, the thread or process to determine if a first lock on the first mutex object is held by any of the other threads or processes, the thread or process arranged to wait until the first lock becomes available; causing the mutex creation routine to create a second mutex lock object if no match is determined, placing the second mutex lock object in the defined object pool at a second known memory location for one of a second time period for which the thread or process or other threads or processes holds lock on the second mutex lock object or a predetermined second time interval from a last time a lock was released on the second mutex lock object and providing the second mutex lock object to the thread or process; scanning the defined object pool at configured time intervals or defined moments to verify whether the first or second mutex lock objects are locked by any thread or process; and removing the first or second mutex lock objects based on one or more conditions to include no threads or processes holding locks on the first or second mutex lock objects or the predetermined time interval since expired for the first or second mutex lock objects.
 3. The method of claim 1, comprising programmer defined to further include chosen attributes for the environment settings under which the thread or process execution takes place, the chosen attributes representing critical section behavior used by the mutex creation routine to create the first mutex lock object, the thread or process in execution to have information about state and environment conditions during execution, the chosen attributes also based on a nature of an application having the critical section, the shared data structure which is to be modified by the critical section or a given type or extent of modification of the shared data structure possible within the critical section, configuration or write logic to extract environment settings for the thread or process in execution based on information known about the critical section and a use case the critical section will be addressing in the application having the critical section, the first mutex lock object created and lock contention managed by: placing the first mutex lock object in a defined object pool at a first known memory location; locking the first mutex lock object by the thread or process before the thread or process executes the critical section; determining that another thread or processes approaches another critical section which modifies the shared data structure; comparing the chosen attributes to the other critical section behavior to include a given type of modification to the shared data structure during execution of the other critical section; determining if the chosen attributes for the critical section is different from the other critical section behavior, the difference to result in a second context object; causing the mutex creation routine to create a second mutex lock object using the second context object, placing the second mutex lock object in the defined object pool at a second known memory location; and locking the second mutex lock object by the other thread or process before the other thread or process executes the other critical section.
 4. The method of claim 1, comprising the programmer defined context object is defined such that even if different critical sections modify the shared data structure based on the environment settings and the defined critical section behavior for the different critical sections, the context object is a same or a different context object and mutex lock objects created by the mutex creation routine based on the context object may be a same or a different mutex lock object, the same or different mutex lock object to enable concurrent execution of multiple critical sections of an application by threads or processes based on at least one of the application's need, critical section behavior, the shared data structure or use cases for the application, the same or different mutex lock object to also enable throttling or controlling execution of the multiple critical sections in a configurable manner responsive to adjusting or redefining the programmer defined context object.
 5. The method of claim 1, comprising the programmer defined context object is defined so that multiple threads or processes have different mutex lock objects created by the mutex creation routine such that protection of the shared data structure from corruption is balanced with performance of an application having multiple critical sections accessing the shared data structure when executed by separate threads or processes, a more narrow defined context object to cause higher protection and lower performance, a more coarse defined context object to cause lower protection and higher performance.
 6. A method to manage locks, comprising: creating a first mutual exclusion (mutex) lock object for a first thread to acquire a first lock to access a shared data structure when executing a first critical block of code, the first mutex lock object having a first primary object associated with a first input parameter used by the first thread to execute the first critical block of code, the first mutex lock object also having a first secondary object associated with a first context via which the first thread executes the first critical block of code; storing the first mutex lock object in a shared memory; and providing to the first thread a first indication as to where the first mutex lock object has been stored in the shared memory, the first thread capable of acquiring the first lock to access the shared data structure using the first mutex lock object.
 7. The method of claim 6, comprising: creating a second mutex lock object for a second thread to acquire a second lock to access the shared data structure when executing a second critical block of code, the second mutex lock object having a second primary object associated with a second input parameter used by the second thread to execute the second critical block of code, the second mutex lock object also having a second secondary object associated with a second context via which the second thread executes the second critical block of code; storing the second mutex lock object in the shared memory; and providing to the second thread a second indication as where the second mutex lock object has been stored in the shared memory, the second thread capable of acquiring the second lock to access the shared data structure using the second mutex lock object.
 8. The method of claim 7, comprising at least one of the first input parameter is different from the second input parameter or the first context is different from the second context.
 9. The method of claim 6, comprising receiving the first primary object and the first secondary object in a mutex lock object request from the first thread and implementing a routine responsive to the mutex lock object request, the routine to create the first mutex lock object as a first monitor and store the first monitor in the shared memory.
 10. The method of claim 6, comprising: determining that the first thread has released the acquired first lock; and removing the first mutex lock object from the shared memory based on a determination of whether another thread has acquired the first lock.
 11. The method of claim 6, the first input parameter comprising one of an input data structure or a composite of input data structures to be used by the first thread to execute the first critical block of code.
 12. The method of claim 6, the first context comprising one of a delete operation, an add operation, a map operation, an update operation, a create operation, an unmap operation or an attribute associated with at least one of the delete, add, map or update operation, the attribute configurable based on balancing performance when executing the first critical block of code with protection of the shared data structure.
 13. The method of claim 6, providing the first indication as to where the first mutex lock object has been stored in the shared memory comprises providing one of a pointer to a location in the shared memory where the first mutex lock object has been stored or a hash to determine where the first mutex lock object has been stored.
 14. The method of claim 6, comprising the first thread to acquire the first lock to access the shared data structure using the first mutex lock object based on whether the first mutex lock object indicates another thread has acquired the first lock.
 15. An apparatus comprising: circuitry for executing a multi-threaded program; a create module for execution by the circuitry to create a first mutual exclusion (mutex) lock object for a first thread to acquire a first lock to access a shared data structure when executing a first critical block of code as part of the multi-threaded program, the first mutex lock object having a first primary object associated with a first input parameter used by the first thread to execute the first critical block of code, the first mutex lock object also having a first secondary object associated with a first context via which the first thread executes the first critical block of code; a store module for execution by the circuitry to store the first mutex lock object in a shared memory; and an indicate module for execution by the circuitry to provide to the first thread a first indication as to where the first mutex lock object has been stored in the shared memory, the first thread to acquire the first lock to access the shared data structure using the first mutex lock object.
 16. The apparatus of claim 15, comprising: the create module to create a second mutex lock object for a second thread to acquire a second lock to access the shared data structure when executing a second critical block of code as part of the multi-threaded program, the second mutex lock object having a second primary object associated with a second input parameter used by the second thread to execute the second critical block of code, the second mutex lock object also having a second secondary object associated with a second context via which the second thread executes the second critical block of code; the store module to store the second mutex lock object in the shared memory; and the indicate module to provide to the second thread a second indication as to where the second mutex lock object has been stored in the shared memory, the second thread to acquire the second lock to access the shared data structure using the second mutex lock object.
 17. The apparatus of claim 16, comprising at least one of the first input parameter is different than the second input parameter or the first context is different that the second context.
 18. The apparatus of claim 15, comprising: a received module for execution by the circuitry to receive the first primary object and the first secondary object in a mutex lock object request from the first thread.
 19. The apparatus of claim 18, comprising the receive module, the create module, the store module and the indicate module included in an object routine capable of implementing a routine responsive to the first mutex lock object request, the routine to include the create module creating the first mutex lock object as a first monitor, the store module storing the first monitor in the shared memory and the indicate module providing the first indication as to where the first monitor has been stored in the shared memory.
 20. The apparatus of claim 15, comprising: a clean module for execution by the circuitry to receive an indication that the first thread has released the acquired first lock and cause the first mutex lock object to be removed from the shared memory based on a determination of whether another thread has acquired the first lock. 